unit Spiel;

interface

Uses Classes, Unit2, Konst;

Type TSpielerArray = Array [1..2] of TSpieler;

Type TErgebnis = Class(TObject)
      Heim, Auswaerts : Integer;

      Constructor Create_new;
      Constructor Create_from_Integer(HeimS, AuswaertsS:Integer);
      Constructor Create_From_String(S:String);
      Constructor Create(Var Eingabe:Text);
      Constructor CreateFromStringList( List:TObject; Var Position:Integer);
      Constructor Create_Copy(Erg:TErgebnis);
      Function Speichern(Var Ausgabe:TObject):Integer;
      Procedure setzen(H,A:Integer);
      Function Ergebnis_String:String;
      Function Ergebnis_String_turned:String;
      Function Ergebnis_StringF(Platz:Integer):String;
      Function Sieg:Integer; { -1 : Heimsieg, 0: Unentschieden-Kein Sieger, 1:Auswsieg}
      Procedure Swap;
      Procedure Add(Summand:TErgebnis);
End;

Type TSpiel = class(TObject)
      HeimSpieler,
      AuswaertsSpieler : TSpielerArray;
      Doppel           : Boolean;
      Saetze           : TErgebnis;
      Gespielt         : Boolean;
      Gewertet         : Boolean;

      Constructor Create_new;
      Constructor Create_from_Data(Heim,Auswaerts:TSpieler;
                                   HeimS, AuswaertsS:Integer;
                                   Gesp, Gew : Boolean);
      Constructor Create_Doppel_from_Data(Heim1,Heim2,
                                          Auswaerts1,Auswaerts2:TSpieler;
                                          HeimS, AuswaertsS:Integer;
                                          Gesp, Gew : Boolean);
      Constructor Create_Copy(Spiel:TSpiel);
      Constructor Create(Var Eingabe:Text);
      Constructor CreateFromStringList( List:TObject; Var Position:Integer);
      Destructor Destroy; override;
      Function Speichern(Var Ausgabe:TObject):Integer;
      Function Spieler_String(Var Spieler:TSpielerArray;
                              Mannschaft:Integer;
                              Verein_anzeigen:Boolean):String;
      Function Spiel_String_mit_Markierung(Verein1,HeimPos,Verein2,AuswPos:Integer;
                              Verein_anzeigen, HeimMarkieren, Sieg:Boolean):String;
      Function Spiel_String(Verein1,Verein2:Integer;Verein_anzeigen:Boolean):String;
      Function Sieg:Integer;
      Procedure PassnummerAendern( PnrAlt, PnrNeu : Integer);
End;


implementation

Uses Klass, Best, UOptionen, SysUtils;

{***************************************************************************}
{***************          Klasse TErgebnis         *************************}
{***************************************************************************}

Constructor TErgebnis.Create_new;
Begin
 Heim := 0;
 Auswaerts := 0;
End;

Constructor TErgebnis.Create_from_Integer(HeimS, AuswaertsS:Integer);
Begin
 Heim := HeimS;
 Auswaerts := AuswaertsS;
End;

Constructor TErgebnis.Create_Copy(Erg:TErgebnis);
Begin
 Heim := Erg.Heim;
 Auswaerts := Erg.Auswaerts;
End;

Constructor TErgebnis.Create_From_String(S:String);
Var S1, S2      : String;
    Doppelpunkt : Integer;
Begin
 S := Trim(S);
 Doppelpunkt := Pos(':', S);
 S1 := Copy(S,1,Doppelpunkt-1);
 S2 := Copy(S,Doppelpunkt+1,Length(s)-Doppelpunkt);
 Val(S1,Heim,Doppelpunkt);
 Val(S2,Auswaerts,Doppelpunkt);
End;

Constructor TErgebnis.Create(Var Eingabe:Text);
Begin
 {$I-}
 Readln(Eingabe,Heim);
 Readln(Eingabe,Auswaerts);
 {$I+}
End;

Constructor TErgebnis.CreateFromStringList( List:TObject; Var Position:Integer);
Begin
 Heim := StrToInt( ReadlnFromStringList(List, Position) );
 Auswaerts := StrToInt( ReadlnFromStringList(List, Position) );
End;

Function TErgebnis.Speichern(Var Ausgabe:TObject):Integer;
Begin
 {$I-}
 WritelnToObject(Ausgabe, IntToStr(Heim) );
 WritelnToObject(Ausgabe, IntToStr(Auswaerts) );
 Speichern := IOResult;
 {$I+}
End;

Procedure TErgebnis.setzen(H,A:Integer);
Begin
 Heim := H;
 Auswaerts := A;
End;

Function TErgebnis.Ergebnis_String:String;
Var S, T : String;
Begin
 If (Heim = 0) And (Auswaerts = 0) then Ergebnis_String := '   '
 else
  Begin
   Str(Heim,S);
   Str(Auswaerts,T);
   Ergebnis_String := S + ':' + T;
  End;
End;

Function TErgebnis.Ergebnis_String_turned:String;
Var S, T : String;
Begin
 If (Heim = 0) And (Auswaerts = 0) then Ergebnis_String_turned := ''
 else
  Begin
   Str(Heim,S);
   Str(Auswaerts,T);
   Ergebnis_String_turned := T + ':' + S;
  End;
End;

Function TErgebnis.Ergebnis_StringF(Platz:Integer):String;
Var S, T : String;
Begin
 Str(Heim:Platz,S);
 Str(Auswaerts:Platz,T);
 Ergebnis_StringF := S + ':' + T;
End;

Function TErgebnis.Sieg:Integer;
Begin
 Sieg := 0;
 If Heim > Auswaerts then Sieg := -1
  else if Heim < Auswaerts then Sieg := 1
End;

Procedure TErgebnis.Swap;
Var T : Integer;
Begin
 T := Heim;
 Heim := Auswaerts;
 Auswaerts := T;
End;

Procedure TErgebnis.Add(Summand:TErgebnis);
Begin
 Heim := Heim + Summand.Heim;
 Auswaerts := Auswaerts + Summand.Auswaerts;
End;


{***************************************************************************}
{***************          Klasse TSpiel            *************************}
{***************************************************************************}


Constructor TSpiel.Create_new;
Begin
 Gespielt := False;
 Gewertet := False;
 Doppel := False;
 HeimSpieler[1] := TSpieler.Create_New;
 HeimSpieler[2] := TSpieler.Create_New;
 AuswaertsSpieler[1] := TSpieler.Create_New;
 AuswaertsSpieler[2] := TSpieler.Create_New;
 Saetze := TErgebnis.Create_New;
End;

Constructor TSpiel.Create_from_Data(Heim,Auswaerts:TSpieler;
                                    HeimS, AuswaertsS:Integer;
                                    Gesp, Gew: Boolean);
Begin
 Doppel := False;
 HeimSpieler[1] := TSpieler.Create_Copy(Heim);
 HeimSpieler[2] := TSpieler.Create_new;
 AuswaertsSpieler[1] := TSpieler.Create_Copy(Auswaerts);
 AuswaertsSpieler[2] := TSpieler.Create_new;
 Saetze := TErgebnis.Create_from_Integer(HeimS,AuswaertsS);
 Gespielt := Gesp;
 Gewertet := Gew;
End;

Constructor TSpiel.Create_Doppel_from_Data(Heim1,Heim2,
                                           Auswaerts1,Auswaerts2:TSpieler;
                                           HeimS, AuswaertsS:Integer;
                                           Gesp, Gew: Boolean);
Begin
 Doppel := True;
 HeimSpieler[1] := TSpieler.Create_Copy(Heim1);
 HeimSpieler[2] := TSpieler.Create_Copy(Heim2);
 AuswaertsSpieler[1] := TSpieler.Create_Copy(Auswaerts1);
 AuswaertsSpieler[2] := TSpieler.Create_Copy(Auswaerts2);
 Saetze := TErgebnis.Create_from_Integer(HeimS,AuswaertsS);
 Gespielt := Gesp;
 Gewertet := Gew;
End;


Constructor TSpiel.Create_Copy(Spiel:TSpiel);
Begin
 Doppel := Spiel.Doppel;
 HeimSpieler[1] := TSpieler.Create_Copy(Spiel.HeimSpieler[1]);
 HeimSpieler[2] := TSpieler.Create_Copy(Spiel.HeimSpieler[2]);
 AuswaertsSpieler[1] := TSpieler.Create_Copy(Spiel.AuswaertsSpieler[1]);
 AuswaertsSpieler[2] := TSpieler.Create_Copy(Spiel.AuswaertsSpieler[2]);
 Saetze := TErgebnis.Create_Copy(Spiel.Saetze);
 Gespielt := Spiel.Gespielt;
 Gewertet := Spiel.Gewertet;
End;

Constructor TSpiel.Create(Var Eingabe:Text);
Var S : String;
Begin
 {$I-}
 Readln(Eingabe,S);
 If (S='Gewertet') Then
 Begin
   Gewertet := True;
   Readln(Eingabe,S);
 End
 else Gewertet := False;

 If (S='Gespielt') then Gespielt := True
  else Gespielt := False;
 Readln(Eingabe,S);

 If (S='Doppel') then Doppel := True
  else Doppel := False;
 HeimSpieler[1] := TSpieler.Create(Eingabe);
 If Doppel then HeimSpieler[2] := TSpieler.Create(Eingabe)
  else HeimSpieler[2] := TSpieler.Create_new;
 AuswaertsSpieler[1] := TSpieler.Create(Eingabe);
 If Doppel then AuswaertsSpieler[2] := TSpieler.Create(Eingabe)
  else AuswaertsSpieler[2] := TSpieler.Create_new;
 Saetze := TErgebnis.Create(Eingabe);
 {$I+}
End;

Constructor TSpiel.CreateFromStringList( List:TObject; Var Position:Integer);
Var S : String;
Begin
 S := ReadlnFromStringList(List, Position);
 If (S='Gewertet') Then
 Begin
   Gewertet := True;
   S := ReadlnFromStringList(List, Position);
 End
 else Gewertet := False;

 If (S='Gespielt') then Gespielt := True
  else Gespielt := False;
 S := ReadlnFromStringList(List, Position);

 If (S='Doppel') then Doppel := True
  else Doppel := False;
 HeimSpieler[1] := TSpieler.CreateFromStringList(List, Position);
 If Doppel then HeimSpieler[2] := TSpieler.CreateFromStringList(List, Position)
  else HeimSpieler[2] := TSpieler.Create_new;
 AuswaertsSpieler[1] := TSpieler.CreateFromStringList(List, Position);
 If Doppel then AuswaertsSpieler[2] := TSpieler.CreateFromStringList(List, Position)
  else AuswaertsSpieler[2] := TSpieler.Create_new;
 Saetze := TErgebnis.CreateFromStringList(List, Position);
End;

Function TSpiel.Speichern(Var Ausgabe:TObject):Integer;
Var Fehler : Integer;
Begin
 {$I-}
 Fehler := 0;
 If Gewertet then WritelnToObject(Ausgabe,'Gewertet');
 If Gespielt then WritelnToObject(Ausgabe,'Gespielt')
  else WritelnToObject(Ausgabe,'Nicht gespielt');
 If Doppel then WritelnToObject(Ausgabe,'Doppel')
  else WritelnToObject(Ausgabe,'Einzel');
 Fehler := IOResult;
 If Fehler = 0 then Fehler := HeimSpieler[1].Speichern(Ausgabe);
 If (Fehler = 0) And Doppel then Fehler := HeimSpieler[2].Speichern(Ausgabe);
 If Fehler = 0 then Fehler := AuswaertsSpieler[1].Speichern(Ausgabe);
 If (Fehler = 0) And Doppel then Fehler := AuswaertsSpieler[2].Speichern(Ausgabe);
 If Fehler = 0 then Fehler := Saetze.Speichern(Ausgabe);
 Speichern := Fehler;
 {$I+}
End;

Destructor TSpiel.Destroy;
Begin
 HeimSpieler[1].Free;
 HeimSpieler[2].Free;
 AuswaertsSpieler[1].Free;
 AuswaertsSpieler[2].Free;
 Saetze.Free;
 inherited Destroy;
End;

Function TSpiel.Spieler_String(Var Spieler:TSpielerArray;
                               Mannschaft:Integer;
                               Verein_anzeigen:Boolean):String;
Var Sp, Sp1, E : String;
    Teamnr     : Integer;
Begin
 If ( Not Doppel And ( Spieler[1].Passnummer = 0 ) ) Or
    ( Doppel And ( Spieler[1].Passnummer = 0 ) And ( Spieler[2].Passnummer = 0 ) ) then
  Spieler_String := Copy('                                             ',1,Name_Length+13)
 else
  Begin
   E := '';
   TeamNr := Klasse.Mannschaft(Mannschaft).Nummer;
   If {(TeamNr <> Spieler[1].Mannschaft) And
      (Not Doppel Or (TeamNr <> Spieler[2].Mannschaft)) then}
      ((Teamnr <> Meldebogen.TeamNummer_(Spieler[1])) And Not Doppel) Or
      (Doppel And ( (Teamnr <> Meldebogen.TeamNummer_(Spieler[1])) Or
                    ( Teamnr <> Meldebogen.TeamNummer_(Spieler[2])) ) ) then
    E := ' (E)';
   // If Ersatzspieler(TeamNr) then
   //  If ObenFestgespielt(TeamNr) Then E := ' (EF)'
   // else E := ' (E)';

   If Not Doppel then
    Begin
     Sp := Copy(Spieler[1].Name,1,Name_Length-Length(E))+E;
    End
   else
    Begin
     Sp := Spieler[1].Name;
     Sp1 := Spieler[2].Name;
     If Name_Length > 0 then
      While Length(Sp + '/' + Sp1 + E)> Name_Length Do
       If Length(Sp) > Length(Sp1) then
        Sp := Copy(Sp,1,Length(Sp)-1)
       else Sp1 := Copy(Sp1,1,Length(Sp1)-1);
     Sp := Sp + '/' + Sp1 + E;
    End;
   If Verein_anzeigen then
   Begin
    Sp := Sp + ' (' + Klasse.Teamname(Mannschaft);
    Sp := Copy(Sp,1,Name_Length+12)+ ')';
   End;
   If Not Optionen.Tabellarisch then
     Sp := Copy(Sp+'                                             ',1,Name_Length+13);
   Spieler_String := Sp;
  End;
End;

Function TSpiel.Spiel_String(Verein1,Verein2:Integer; Verein_anzeigen:Boolean):String;
Begin
 If Optionen.Tabellarisch Then
  Spiel_String := Spieler_String(HeimSpieler, Verein1, Verein_anzeigen) + '@-@' +
                  Spieler_String(AuswaertsSpieler, Verein2, Verein_anzeigen) +
                  '@' + Saetze.Ergebnis_String
 else
  Spiel_String := Spieler_String(HeimSpieler, Verein1, Verein_anzeigen) + ' - ' +
                  Spieler_String(AuswaertsSpieler, Verein2, Verein_anzeigen) +
                  ' ' + Saetze.Ergebnis_String ;
End;

Function TSpiel.Spiel_String_mit_Markierung(Verein1,HeimPos,Verein2,AuswPos:Integer;
                  Verein_anzeigen, HeimMarkieren, Sieg :Boolean):String;
Var Text1, Text2, Farbe, Ende, HeimPosS, AuswPosS : String;
Begin
 Str( HeimPos, HeimPosS );
 Str( AuswPos, AuswPosS );
 If Optionen.Tabellarisch Then
 Begin
  If Optionen.Ausgabe = AlsHtml then
   Begin
{$IFDEF Server}
    Ende := '</Font>';
    If Sieg then Farbe := '<Font Class="Sieg">'
    else Farbe := '<Font Class="Niederlage">';
{$ELSE}
    Ende := '</font>';
    If Sieg then Farbe := '<font color="#008000">'
    else Farbe := '<font color="#FF0000">';
{$ENDIF}
   End
  else
   Begin
    Ende := '';
    Farbe := '';
   End;
  Text1 := Spieler_String(HeimSpieler, Verein1, Verein_anzeigen);
  Text2 := Spieler_String(AuswaertsSpieler, Verein2, Verein_anzeigen);
  If HeimMarkieren then Text1 := Farbe + Text1 + Ende
  else Text2 := Farbe + Text2 + Ende;
  Spiel_String_mit_Markierung := HeimPosS + ' ' + Text1 + '@ - @' + AuswPosS + ' ' + Text2 + '@' + Saetze.Ergebnis_String;
 End
 else
  Spiel_String_mit_Markierung := HeimPosS + ' ' + Spieler_String(HeimSpieler, Verein1, Verein_anzeigen) + ' - ' +
                  AuswPosS + ' ' + Spieler_String(AuswaertsSpieler, Verein2, Verein_anzeigen) +
                  ' ' + Saetze.Ergebnis_String ;
End;

Function TSpiel.Sieg:Integer;
Begin
  Sieg := Saetze.Sieg;
End;

Procedure TSpiel.PassnummerAendern( PnrAlt, PnrNeu : Integer);
Begin
 If Doppel then
  Begin
   HeimSpieler[1].PassnummerAendern( PnrAlt, PnrNeu );
   HeimSpieler[2].PassnummerAendern( PnrAlt, PnrNeu );
   AuswaertsSpieler[1].PassnummerAendern( PnrAlt, PnrNeu );
   AuswaertsSpieler[2].PassnummerAendern( PnrAlt, PnrNeu );
  End
 else
  Begin
   HeimSpieler[1].PassnummerAendern( PnrAlt, PnrNeu );
   AuswaertsSpieler[1].PassnummerAendern( PnrAlt, PnrNeu );
  End;
End;

end.
